home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 22 / CU Amiga Magazine's Super CD-ROM 22 (1998)(EMAP Images)(GB)[!][issue 1998-05].iso / PowerPC / Programming / PPCSmallEiffel / bin_c / compile_to_jvm6.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-01-16  |  17.7 KB  |  659 lines
  1. /*
  2. -- ANSI C code generated by :
  3. -- SmallEiffel The GNU Eiffel Compiler -- Release (- 0.82)      --
  4. -- Copyright (C), 1994-98 - LORIA - UHP - CRIN - INRIA - FRANCE --
  5. -- Dominique COLNET and Suzanne COLLIN -    colnet@loria.fr     --
  6. --                 http://www.loria.fr/SmallEiffel              --
  7. */
  8. #include "compile_to_jvm.h"
  9. void r477clear_all(T477* C){
  10. T0* _value=NULL;
  11. /*[IRF3.6set_all_with*/{T477* C1=C;
  12. T0* b1=_value;
  13. r778set_all_with((((T477*)C1))->_storage/*4*/,b1,((((T477*)C1))->_upper/*12*/)-((((T477*)C1))->_lower/*16*/));
  14. }/*]*/
  15. }
  16. /*No:ARRAY[RUN_FEATURE].set_all_with*/
  17. void r477force(T477* C,T0* a1,int a2){
  18. /*IF*/if (((((T477*)C))->_upper/*12*/)<(a2)) {
  19. r477resize(C,(((T477*)C))->_lower/*16*/,a2);
  20. }
  21.  else if ((a2)<((((T477*)C))->_lower/*16*/)) {
  22. r477resize(C,a2,(((T477*)C))->_upper/*12*/);
  23. }
  24. /*FI*//*[IRF3.6put*/{T477* C1=C;
  25. T0* b1=a1;
  26. int b2=a2;
  27. ((((T477*)C1))->_storage/*4*/)[(b2)-((((T477*)C1))->_lower/*16*/)]=(b1);
  28. }/*]*/
  29. }
  30. void r477make(T477* C,int a1,int a2){
  31. int _needed=0;
  32. C->_lower=a1;
  33. C->_upper=a2;
  34. _needed=((a2)-(a1))+(1);
  35. /*IF*/if ((_needed)>(0)) {
  36. /*IF*/if (((((T477*)C))->_capacity/*8*/)<(_needed)) {
  37. /*IF*/if (((((T477*)C))->_capacity/*8*/)==(0)) {
  38. C->_storage=calloc(_needed,sizeof(T0*));
  39. }
  40. else {
  41. C->_storage=calloc(_needed,sizeof(T0*));
  42. }
  43. /*FI*/C->_capacity=_needed;
  44. }
  45. else {
  46. r477clear_all(C);
  47. }
  48. /*FI*/}
  49. /*FI*/}
  50. T0* r477item(T477* C,int a1){
  51. T0* R=NULL;
  52. R=((((T477*)C))->_storage/*4*/)[(a1)-((((T477*)C))->_lower/*16*/)];
  53. return R;
  54. }
  55. void r477resize(T477* C,int a1,int a2){
  56. int _mem=0;
  57. int _up=0;
  58. int _i=0;
  59. T0* _other=NULL;
  60. {T477*n=malloc(sizeof(*n));
  61. *n=M477;
  62. r477make(n,a1,a2);
  63. _other=(T0*)n;
  64. }
  65. _i=r2max((((T477*)C))->_lower/*16*/,/*X477*/((int)(((T477*)((T477*)_other)))->_lower/*16*/));
  66. _up=r2min((((T477*)C))->_upper/*12*/,/*X477*/((int)(((T477*)((T477*)_other)))->_upper/*12*/));
  67. while (!((_i)>(_up))) {
  68. /*X477*//*[IRF3.6put*/{T477* C1=((T477*)_other);
  69. T0* b1=r477item(C,_i);
  70. int b2=_i;
  71. ((((T477*)C1))->_storage/*4*/)[(b2)-((((T477*)C1))->_lower/*16*/)]=(b1);
  72. }/*]*/
  73. _i=(_i)+(1);
  74. }
  75. *((T477*)(C))=*((T477*)(_other));
  76. }
  77. /*No:ARRAY[RUN_FEATURE].storage*/
  78. /*No:ARRAY[RUN_FEATURE].capacity*/
  79. /*No:ARRAY[RUN_FEATURE].lower*/
  80. /*No:ARRAY[RUN_FEATURE].put*/
  81. /*No:ARRAY[RUN_FEATURE].upper*/
  82. int r477count(T477* C){
  83. int R=0;
  84. R=(((((T477*)C))->_upper/*12*/)-((((T477*)C))->_lower/*16*/))+(1);
  85. return R;
  86. }
  87. T0* r147item(T147* C,int a1){
  88. T0* R=NULL;
  89. R=((((T147*)C))->_storage/*0*/)[(a1)-((((T147*)C))->_lower/*12*/)];
  90. return R;
  91. }
  92. /*No:ARRAY[E_WHEN].storage*/
  93. T0* r147twin(T147* C){
  94. T0* R=NULL;
  95. R=malloc(sizeof(*C));
  96. *((T147*)R)=M147;
  97. r147copy(((T147*)R),((T0*)C));
  98. return R;
  99. }
  100. /*No:ARRAY[E_WHEN].capacity*/
  101. void r147copy(T147* C,T0* a1){
  102. int _needed_capacity=0;
  103. C->_lower=(((T147*)((T147*)a1)))->_lower/*12*/;
  104. C->_upper=(((T147*)((T147*)a1)))->_upper/*8*/;
  105. _needed_capacity=(((((T147*)C))->_upper/*8*/)-((((T147*)C))->_lower/*12*/))+(1);
  106. /*IF*/if (((((T147*)C))->_capacity/*4*/)<(_needed_capacity)) {
  107. C->_capacity=_needed_capacity;
  108. C->_storage=calloc((((T147*)C))->_capacity/*4*/,sizeof(T0*));
  109. }
  110. /*FI*//*IF*/if ((_needed_capacity)>(0)) {
  111. r586copy_from((((T147*)C))->_storage/*0*/,(((T147*)((T147*)a1)))->_storage/*0*/,(_needed_capacity)-(1));
  112. }
  113. /*FI*/}
  114. /*No:ARRAY[E_WHEN].lower*/
  115. /*No:ARRAY[E_WHEN].put*/
  116. /*No:ARRAY[E_WHEN].upper*/
  117. int r147count(T147* C){
  118. int R=0;
  119. R=(((((T147*)C))->_upper/*8*/)-((((T147*)C))->_lower/*12*/))+(1);
  120. return R;
  121. }
  122. void r147add_last(T147* C,T0* a1){
  123. int _new_capacity=0;
  124. /*IF*/if (((((T147*)C))->_capacity/*4*/)<((r147count(C))+(1))) {
  125. /*IF*/if (((((T147*)C))->_capacity/*4*/)==(0)) {
  126. C->_capacity=16;
  127. C->_storage=calloc((((T147*)C))->_capacity/*4*/,sizeof(T0*));
  128. }
  129. else {
  130. _new_capacity=(2)*((((T147*)C))->_capacity/*4*/);
  131. C->_storage=r586realloc((((T147*)C))->_storage/*0*/,(((T147*)C))->_capacity/*4*/,_new_capacity);
  132. C->_capacity=_new_capacity;
  133. }
  134. /*FI*/}
  135. /*FI*/C->_upper=((((T147*)C))->_upper/*8*/)+(1);
  136. /*[IRF3.6put*/{T147* C1=C;
  137. T0* b1=a1;
  138. int b2=(((T147*)C))->_upper/*8*/;
  139. ((((T147*)C1))->_storage/*0*/)[(b2)-((((T147*)C1))->_lower/*12*/)]=(b1);
  140. }/*]*/
  141. }
  142. /*No:FIXED_ARRAY[TYPE_BIT_REF].item*/
  143. /*No:FIXED_ARRAY[TYPE_BIT_REF].storage*/
  144. /*No:FIXED_ARRAY[TYPE_BIT_REF].capacity*/
  145. void r41with_capacity(T41* C,int a1){
  146. /*IF*/if (((((T41*)C))->_capacity/*8*/)<(a1)) {
  147. C->_storage=calloc(a1,sizeof(T0*));
  148. C->_capacity=a1;
  149. }
  150. /*FI*/C->_upper=-(1);
  151. }
  152. /*No:FIXED_ARRAY[TYPE_BIT_REF].put*/
  153. /*No:FIXED_ARRAY[TYPE_BIT_REF].upper*/
  154. void r41add_last(T41* C,T0* a1){
  155. int _new_capacity=0;
  156. /*IF*/if ((((((T41*)C))->_upper/*12*/)+(1))<=(((((T41*)C))->_capacity/*8*/)-(1))) {
  157. C->_upper=((((T41*)C))->_upper/*12*/)+(1);
  158. }
  159.  else if (((((T41*)C))->_capacity/*8*/)==(0)) {
  160. C->_storage=calloc(2,sizeof(T0*));
  161. C->_capacity=2;
  162. C->_upper=0;
  163. }
  164. else {
  165. _new_capacity=(2)*((((T41*)C))->_capacity/*8*/);
  166. C->_storage=r539realloc((((T41*)C))->_storage/*4*/,(((T41*)C))->_capacity/*8*/,_new_capacity);
  167. C->_capacity=_new_capacity;
  168. C->_upper=((((T41*)C))->_upper/*12*/)+(1);
  169. }
  170. /*FI*//*[IRF3.5put*/((((T41*)C))->_storage/*4*/)[(((T41*)C))->_upper/*12*/]=(a1);
  171. /*]*/
  172. }
  173. /*No:FIXED_ARRAY[INTEGER].clear_all*/
  174. /*No:FIXED_ARRAY[INTEGER].set_all_with*/
  175. void r226make(T226* C,int a1){
  176. /*IF*/if ((a1)==(0)) {
  177. C->_upper=-(1);
  178. }
  179.  else if (((((T226*)C))->_capacity/*4*/)==(0)) {
  180. C->_storage=calloc(a1,sizeof(int));
  181. C->_capacity=a1;
  182. C->_upper=(a1)-(1);
  183. }
  184.  else if (((((T226*)C))->_capacity/*4*/)<(a1)) {
  185. C->_storage=calloc(a1,sizeof(int));
  186. C->_capacity=a1;
  187. C->_upper=(a1)-(1);
  188. }
  189. else {
  190. C->_upper=(a1)-(1);
  191. /*[IRF3.6clear_all*/{T226* C1=C;
  192. int __value=0;
  193. /*[IRF3.6set_all_with*/{T226* C2=C1;
  194. int c1=__value;
  195. r686set_all_with((((T226*)C2))->_storage/*0*/,c1,(((T226*)C2))->_upper/*8*/);
  196. }/*]*/
  197. }/*]*/
  198. }
  199. /*FI*/}
  200. int r226fast_has(T226* C,int a1){
  201. int R=0;
  202. /*IF*/if ((/*(IRF4.6count*/((((T226*)C))->_upper/*8*/)+(1)/*)*/)>(0)) {
  203. R=(r226fast_index_of(C,a1))<=((((T226*)C))->_upper/*8*/);
  204. }
  205. /*FI*/return R;
  206. }
  207. /*No:FIXED_ARRAY[INTEGER].item*/
  208. void r226resize(T226* C,int a1){
  209. int _elt_default=0;
  210. int _i=0;
  211. int _new_capacity=0;
  212. /*IF*/if ((a1)<=(/*(IRF4.6count*/((((T226*)C))->_upper/*8*/)+(1)/*)*/)) {
  213. C->_upper=(a1)-(1);
  214. }
  215. else {
  216. _new_capacity=a1;
  217. /*IF*/if (((((T226*)C))->_capacity/*4*/)<(_new_capacity)) {
  218. /*IF*/if (((((T226*)C))->_capacity/*4*/)==(0)) {
  219. C->_storage=calloc(_new_capacity,sizeof(int));
  220. }
  221. else {
  222. C->_storage=r686realloc((((T226*)C))->_storage/*0*/,(((T226*)C))->_capacity/*4*/,_new_capacity);
  223. }
  224. /*FI*/C->_capacity=_new_capacity;
  225. }
  226. /*FI*/_new_capacity=(((T226*)C))->_upper/*8*/;
  227. C->_upper=(a1)-(1);
  228. _i=(((T226*)C))->_upper/*8*/;
  229. while (!((_i)==(_new_capacity))) {
  230. /*[IRF3.5put*/((((T226*)C))->_storage/*0*/)[_i]=(_elt_default);
  231. /*]*/
  232. _i=(_i)-(1);
  233. }
  234. }
  235. /*FI*/}
  236. /*No:FIXED_ARRAY[INTEGER].clear*/
  237. /*No:FIXED_ARRAY[INTEGER].storage*/
  238. /*No:FIXED_ARRAY[INTEGER].capacity*/
  239. void r226copy(T226* C,T0* a1){
  240. int _new_capacity=0;
  241. int _other_upper=0;
  242. _other_upper=(((T226*)((T226*)a1)))->_upper/*8*/;
  243. /*IF*/if ((_other_upper)>=(0)) {
  244. _new_capacity=(_other_upper)+(1);
  245. /*IF*/if (((((T226*)C))->_capacity/*4*/)<(_new_capacity)) {
  246. C->_capacity=_new_capacity;
  247. C->_storage=calloc(_new_capacity,sizeof(int));
  248. }
  249.  else if (((((T226*)C))->_capacity/*4*/)>(0)) {
  250. r686clear_all((((T226*)C))->_storage/*0*/,((((T226*)C))->_capacity/*4*/)-(1));
  251. }
  252. /*FI*/r686copy_from((((T226*)C))->_storage/*0*/,(((T226*)((T226*)a1)))->_storage/*0*/,_other_upper);
  253. }
  254.  else if (((((T226*)C))->_capacity/*4*/)>(0)) {
  255. r686clear_all((((T226*)C))->_storage/*0*/,((((T226*)C))->_capacity/*4*/)-(1));
  256. }
  257. /*FI*/C->_upper=_other_upper;
  258. }
  259. /*No:FIXED_ARRAY[INTEGER].lower*/
  260. void r226with_capacity(T226* C,int a1){
  261. /*IF*/if (((((T226*)C))->_capacity/*4*/)<(a1)) {
  262. C->_storage=calloc(a1,sizeof(int));
  263. C->_capacity=a1;
  264. }
  265. /*FI*/C->_upper=-(1);
  266. }
  267. int r226fast_index_of(T226* C,int a1){
  268. int R=0;
  269. R=r686fast_index_of((((T226*)C))->_storage/*0*/,a1,(((T226*)C))->_upper/*8*/);
  270. return R;
  271. }
  272. /*No:FIXED_ARRAY[INTEGER].put*/
  273. /*No:FIXED_ARRAY[INTEGER].upper*/
  274. void r226add_last(T226* C,int a1){
  275. int _new_capacity=0;
  276. /*IF*/if ((((((T226*)C))->_upper/*8*/)+(1))<=(((((T226*)C))->_capacity/*4*/)-(1))) {
  277. C->_upper=((((T226*)C))->_upper/*8*/)+(1);
  278. }
  279.  else if (((((T226*)C))->_capacity/*4*/)==(0)) {
  280. C->_storage=calloc(2,sizeof(int));
  281. C->_capacity=2;
  282. C->_upper=0;
  283. }
  284. else {
  285. _new_capacity=(2)*((((T226*)C))->_capacity/*4*/);
  286. C->_storage=r686realloc((((T226*)C))->_storage/*0*/,(((T226*)C))->_capacity/*4*/,_new_capacity);
  287. C->_capacity=_new_capacity;
  288. C->_upper=((((T226*)C))->_upper/*8*/)+(1);
  289. }
  290. /*FI*//*[IRF3.5put*/((((T226*)C))->_storage/*0*/)[(((T226*)C))->_upper/*8*/]=(a1);
  291. /*]*/
  292. }
  293. /*No:FIXED_ARRAY[INTEGER].count*/
  294. void r32clear_all(T32* C){
  295. T0* _value=NULL;
  296. /*[IRF3.6set_all_with*/{T32* C1=C;
  297. T0* b1=_value;
  298. r500set_all_with((((T32*)C1))->_storage/*4*/,b1,(((T32*)C1))->_upper/*12*/);
  299. }/*]*/
  300. }
  301. /*No:FIXED_ARRAY[EXPRESSION].set_all_with*/
  302. void r32make(T32* C,int a1){
  303. /*IF*/if ((a1)==(0)) {
  304. C->_upper=-(1);
  305. }
  306.  else if (((((T32*)C))->_capacity/*8*/)==(0)) {
  307. C->_storage=calloc(a1,sizeof(T0*));
  308. C->_capacity=a1;
  309. C->_upper=(a1)-(1);
  310. }
  311.  else if (((((T32*)C))->_capacity/*8*/)<(a1)) {
  312. C->_storage=calloc(a1,sizeof(T0*));
  313. C->_capacity=a1;
  314. C->_upper=(a1)-(1);
  315. }
  316. else {
  317. C->_upper=(a1)-(1);
  318. r32clear_all(C);
  319. }
  320. /*FI*/}
  321. void r32resize(T32* C,int a1){
  322. T0* _elt_default=NULL;
  323. int _i=0;
  324. int _new_capacity=0;
  325. /*IF*/if ((a1)<=(r32count(C))) {
  326. C->_upper=(a1)-(1);
  327. }
  328. else {
  329. _new_capacity=a1;
  330. /*IF*/if (((((T32*)C))->_capacity/*8*/)<(_new_capacity)) {
  331. /*IF*/if (((((T32*)C))->_capacity/*8*/)==(0)) {
  332. C->_storage=calloc(_new_capacity,sizeof(T0*));
  333. }
  334. else {
  335. C->_storage=r500realloc((((T32*)C))->_storage/*4*/,(((T32*)C))->_capacity/*8*/,_new_capacity);
  336. }
  337. /*FI*/C->_capacity=_new_capacity;
  338. }
  339. /*FI*/_new_capacity=(((T32*)C))->_upper/*12*/;
  340. C->_upper=(a1)-(1);
  341. _i=(((T32*)C))->_upper/*12*/;
  342. while (!((_i)==(_new_capacity))) {
  343. /*[IRF3.6put*/{T32* C1=C;
  344. T0* b1=_elt_default;
  345. int b2=_i;
  346. ((((T32*)C1))->_storage/*4*/)[b2]=(b1);
  347. }/*]*/
  348. _i=(_i)-(1);
  349. }
  350. }
  351. /*FI*/}
  352. /*No:FIXED_ARRAY[EXPRESSION].storage*/
  353. /*No:FIXED_ARRAY[EXPRESSION].capacity*/
  354. /*No:FIXED_ARRAY[EXPRESSION].put*/
  355. /*No:FIXED_ARRAY[EXPRESSION].upper*/
  356. int r32count(T32* C){
  357. int R=0;
  358. R=((((T32*)C))->_upper/*12*/)+(1);
  359. return R;
  360. }
  361. /*No:ARRAY[DICTIONARY[RUN_FEATURE,STRING]].clear_all*/
  362. /*No:ARRAY[DICTIONARY[RUN_FEATURE,STRING]].set_all_with*/
  363. void r943make(T943* C,int a1,int a2){
  364. int _needed=0;
  365. C->_lower=a1;
  366. C->_upper=a2;
  367. _needed=((a2)-(a1))+(1);
  368. /*IF*/if ((_needed)>(0)) {
  369. /*IF*/if (((((T943*)C))->_capacity/*4*/)<(_needed)) {
  370. /*IF*/if (((((T943*)C))->_capacity/*4*/)==(0)) {
  371. C->_storage=calloc(_needed,sizeof(T0*));
  372. }
  373. else {
  374. C->_storage=calloc(_needed,sizeof(T0*));
  375. }
  376. /*FI*/C->_capacity=_needed;
  377. }
  378. else {
  379. /*[IRF3.6clear_all*/{T943* C1=C;
  380. T0* __value=NULL;
  381. /*[IRF3.6set_all_with*/{T943* C2=C1;
  382. T0* c1=__value;
  383. r354set_all_with((((T943*)C2))->_storage/*0*/,c1,((((T943*)C2))->_upper/*8*/)-((((T943*)C2))->_lower/*12*/));
  384. }/*]*/
  385. }/*]*/
  386. }
  387. /*FI*/}
  388. /*FI*/}
  389. T0* r943item(T943* C,int a1){
  390. T0* R=NULL;
  391. R=((((T943*)C))->_storage/*0*/)[(a1)-((((T943*)C))->_lower/*12*/)];
  392. return R;
  393. }
  394. void r943resize(T943* C,int a1,int a2){
  395. int _mem=0;
  396. int _up=0;
  397. int _i=0;
  398. T0* _other=NULL;
  399. {T943*n=malloc(sizeof(*n));
  400. *n=M943;
  401. r943make(n,a1,a2);
  402. _other=(T0*)n;
  403. }
  404. _i=r2max((((T943*)C))->_lower/*12*/,(((T943*)((T943*)_other)))->_lower/*12*/);
  405. _up=r2min((((T943*)C))->_upper/*8*/,(((T943*)((T943*)_other)))->_upper/*8*/);
  406. while (!((_i)>(_up))) {
  407. /*[IRF3.6put*/{T943* C1=((T943*)_other);
  408. T0* b1=r943item(C,_i);
  409. int b2=_i;
  410. ((((T943*)C1))->_storage/*0*/)[(b2)-((((T943*)C1))->_lower/*12*/)]=(b1);
  411. }/*]*/
  412. _i=(_i)+(1);
  413. }
  414. *((T943*)(C))=*((T943*)(_other));
  415. }
  416. /*No:ARRAY[DICTIONARY[RUN_FEATURE,STRING]].storage*/
  417. /*No:ARRAY[DICTIONARY[RUN_FEATURE,STRING]].capacity*/
  418. /*No:ARRAY[DICTIONARY[RUN_FEATURE,STRING]].lower*/
  419. /*No:ARRAY[DICTIONARY[RUN_FEATURE,STRING]].put*/
  420. /*No:ARRAY[DICTIONARY[RUN_FEATURE,STRING]].upper*/
  421. int r943count(T943* C){
  422. int R=0;
  423. R=(((((T943*)C))->_upper/*8*/)-((((T943*)C))->_lower/*12*/))+(1);
  424. return R;
  425. }
  426. /*No:FIXED_ARRAY[CALL_PROC_CALL].clear_all*/
  427. /*No:FIXED_ARRAY[CALL_PROC_CALL].set_all_with*/
  428. void r569make(T569* C,int a1){
  429. /*IF*/if ((a1)==(0)) {
  430. C->_upper=-(1);
  431. }
  432.  else if (((((T569*)C))->_capacity/*4*/)==(0)) {
  433. C->_storage=calloc(a1,sizeof(T0*));
  434. C->_capacity=a1;
  435. C->_upper=(a1)-(1);
  436. }
  437.  else if (((((T569*)C))->_capacity/*4*/)<(a1)) {
  438. C->_storage=calloc(a1,sizeof(T0*));
  439. C->_capacity=a1;
  440. C->_upper=(a1)-(1);
  441. }
  442. else {
  443. C->_upper=(a1)-(1);
  444. /*[IRF3.6clear_all*/{T569* C1=C;
  445. T0* __value=NULL;
  446. /*[IRF3.6set_all_with*/{T569* C2=C1;
  447. T0* c1=__value;
  448. r98set_all_with((((T569*)C2))->_storage/*0*/,c1,(((T569*)C2))->_upper/*8*/);
  449. }/*]*/
  450. }/*]*/
  451. }
  452. /*FI*/}
  453. /*No:FIXED_ARRAY[CALL_PROC_CALL].item*/
  454. void r569resize(T569* C,int a1){
  455. T0* _elt_default=NULL;
  456. int _i=0;
  457. int _new_capacity=0;
  458. /*IF*/if ((a1)<=(/*(IRF4.6count*/((((T569*)C))->_upper/*8*/)+(1)/*)*/)) {
  459. C->_upper=(a1)-(1);
  460. }
  461. else {
  462. _new_capacity=a1;
  463. /*IF*/if (((((T569*)C))->_capacity/*4*/)<(_new_capacity)) {
  464. /*IF*/if (((((T569*)C))->_capacity/*4*/)==(0)) {
  465. C->_storage=calloc(_new_capacity,sizeof(T0*));
  466. }
  467. else {
  468. C->_storage=r98realloc((((T569*)C))->_storage/*0*/,(((T569*)C))->_capacity/*4*/,_new_capacity);
  469. }
  470. /*FI*/C->_capacity=_new_capacity;
  471. }
  472. /*FI*/_new_capacity=(((T569*)C))->_upper/*8*/;
  473. C->_upper=(a1)-(1);
  474. _i=(((T569*)C))->_upper/*8*/;
  475. while (!((_i)==(_new_capacity))) {
  476. /*[IRF3.5put*/((((T569*)C))->_storage/*0*/)[_i]=(_elt_default);
  477. /*]*/
  478. _i=(_i)-(1);
  479. }
  480. }
  481. /*FI*/}
  482. /*No:FIXED_ARRAY[CALL_PROC_CALL].storage*/
  483. /*No:FIXED_ARRAY[CALL_PROC_CALL].capacity*/
  484. /*No:FIXED_ARRAY[CALL_PROC_CALL].put*/
  485. /*No:FIXED_ARRAY[CALL_PROC_CALL].upper*/
  486. /*No:FIXED_ARRAY[CALL_PROC_CALL].count*/
  487. /*No:ARRAY[INTEGER].clear_all*/
  488. /*No:ARRAY[INTEGER].set_all_with*/
  489. void r429make(T429* C,int a1,int a2){
  490. int _needed=0;
  491. C->_lower=a1;
  492. C->_upper=a2;
  493. _needed=((a2)-(a1))+(1);
  494. /*IF*/if ((_needed)>(0)) {
  495. /*IF*/if (((((T429*)C))->_capacity/*4*/)<(_needed)) {
  496. /*IF*/if (((((T429*)C))->_capacity/*4*/)==(0)) {
  497. C->_storage=calloc(_needed,sizeof(int));
  498. }
  499. else {
  500. C->_storage=calloc(_needed,sizeof(int));
  501. }
  502. /*FI*/C->_capacity=_needed;
  503. }
  504. else {
  505. /*[IRF3.6clear_all*/{T429* C1=C;
  506. int __value=0;
  507. /*[IRF3.6set_all_with*/{T429* C2=C1;
  508. int c1=__value;
  509. r686set_all_with((((T429*)C2))->_storage/*0*/,c1,((((T429*)C2))->_upper/*8*/)-((((T429*)C2))->_lower/*12*/));
  510. }/*]*/
  511. }/*]*/
  512. }
  513. /*FI*/}
  514. /*FI*/}
  515. int r429item(T429* C,int a1){
  516. int R=0;
  517. R=((((T429*)C))->_storage/*0*/)[(a1)-((((T429*)C))->_lower/*12*/)];
  518. return R;
  519. }
  520. void r429resize(T429* C,int a1,int a2){
  521. int _mem=0;
  522. int _up=0;
  523. int _i=0;
  524. T0* _other=NULL;
  525. {T429*n=malloc(sizeof(*n));
  526. *n=M429;
  527. r429make(n,a1,a2);
  528. _other=(T0*)n;
  529. }
  530. _i=r2max((((T429*)C))->_lower/*12*/,(((T429*)((T429*)_other)))->_lower/*12*/);
  531. _up=r2min((((T429*)C))->_upper/*8*/,(((T429*)((T429*)_other)))->_upper/*8*/);
  532. while (!((_i)>(_up))) {
  533. /*[IRF3.6put*/{T429* C1=((T429*)_other);
  534. int b1=r429item(C,_i);
  535. int b2=_i;
  536. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  537. }/*]*/
  538. _i=(_i)+(1);
  539. }
  540. *((T429*)(C))=*((T429*)(_other));
  541. }
  542. /*No:ARRAY[INTEGER].storage*/
  543. /*No:ARRAY[INTEGER].capacity*/
  544. /*No:ARRAY[INTEGER].lower*/
  545. /*No:ARRAY[INTEGER].put*/
  546. /*No:ARRAY[INTEGER].upper*/
  547. void r429add_last(T429* C,int a1){
  548. int _new_capacity=0;
  549. /*IF*/if (((((T429*)C))->_capacity/*4*/)<((r429count(C))+(1))) {
  550. /*IF*/if (((((T429*)C))->_capacity/*4*/)==(0)) {
  551. C->_capacity=16;
  552. C->_storage=calloc((((T429*)C))->_capacity/*4*/,sizeof(int));
  553. }
  554. else {
  555. _new_capacity=(2)*((((T429*)C))->_capacity/*4*/);
  556. C->_storage=r686realloc((((T429*)C))->_storage/*0*/,(((T429*)C))->_capacity/*4*/,_new_capacity);
  557. C->_capacity=_new_capacity;
  558. }
  559. /*FI*/}
  560. /*FI*/C->_upper=((((T429*)C))->_upper/*8*/)+(1);
  561. /*[IRF3.6put*/{T429* C1=C;
  562. int b1=a1;
  563. int b2=(((T429*)C))->_upper/*8*/;
  564. ((((T429*)C1))->_storage/*0*/)[(b2)-((((T429*)C1))->_lower/*12*/)]=(b1);
  565. }/*]*/
  566. }
  567. int r429count(T429* C){
  568. int R=0;
  569. R=(((((T429*)C))->_upper/*8*/)-((((T429*)C))->_lower/*12*/))+(1);
  570. return R;
  571. }
  572. T0* r764item(T764* C,int a1){
  573. T0* R=NULL;
  574. R=((((T764*)C))->_storage/*0*/)[(a1)-((((T764*)C))->_lower/*12*/)];
  575. return R;
  576. }
  577. /*No:ARRAY[FEATURE_CLAUSE].storage*/
  578. /*No:ARRAY[FEATURE_CLAUSE].capacity*/
  579. /*No:ARRAY[FEATURE_CLAUSE].lower*/
  580. /*No:ARRAY[FEATURE_CLAUSE].put*/
  581. /*No:ARRAY[FEATURE_CLAUSE].upper*/
  582. int r764count(T764* C){
  583. int R=0;
  584. R=(((((T764*)C))->_upper/*8*/)-((((T764*)C))->_lower/*12*/))+(1);
  585. return R;
  586. }
  587. void r764add_last(T764* C,T0* a1){
  588. int _new_capacity=0;
  589. /*IF*/if (((((T764*)C))->_capacity/*4*/)<((r764count(C))+(1))) {
  590. /*IF*/if (((((T764*)C))->_capacity/*4*/)==(0)) {
  591. C->_capacity=16;
  592. C->_storage=calloc((((T764*)C))->_capacity/*4*/,sizeof(T0*));
  593. }
  594. else {
  595. _new_capacity=(2)*((((T764*)C))->_capacity/*4*/);
  596. C->_storage=r42realloc((((T764*)C))->_storage/*0*/,(((T764*)C))->_capacity/*4*/,_new_capacity);
  597. C->_capacity=_new_capacity;
  598. }
  599. /*FI*/}
  600. /*FI*/C->_upper=((((T764*)C))->_upper/*8*/)+(1);
  601. /*[IRF3.6put*/{T764* C1=C;
  602. T0* b1=a1;
  603. int b2=(((T764*)C))->_upper/*8*/;
  604. ((((T764*)C1))->_storage/*0*/)[(b2)-((((T764*)C1))->_lower/*12*/)]=(b1);
  605. }/*]*/
  606. }
  607. /*No:FIXED_ARRAY[CP_INFO].clear_all*/
  608. /*No:FIXED_ARRAY[CP_INFO].set_all_with*/
  609. void r515make(T515* C,int a1){
  610. /*IF*/if ((a1)==(0)) {
  611. C->_upper=-(1);
  612. }
  613.  else if (((((T515*)C))->_capacity/*4*/)==(0)) {
  614. C->_storage=calloc(a1,sizeof(T0*));
  615. C->_capacity=a1;
  616. C->_upper=(a1)-(1);
  617. }
  618.  else if (((((T515*)C))->_capacity/*4*/)<(a1)) {
  619. C->_storage=calloc(a1,sizeof(T0*));
  620. C->_capacity=a1;
  621. C->_upper=(a1)-(1);
  622. }
  623. else {
  624. C->_upper=(a1)-(1);
  625. /*[IRF3.6clear_all*/{T515* C1=C;
  626. T0* __value=NULL;
  627. /*[IRF3.6set_all_with*/{T515* C2=C1;
  628. T0* c1=__value;
  629. r995set_all_with((((T515*)C2))->_storage/*0*/,c1,(((T515*)C2))->_upper/*8*/);
  630. }/*]*/
  631. }/*]*/
  632. }
  633. /*FI*/}
  634. /*No:FIXED_ARRAY[CP_INFO].item*/
  635. /*No:FIXED_ARRAY[CP_INFO].storage*/
  636. /*No:FIXED_ARRAY[CP_INFO].capacity*/
  637. /*No:FIXED_ARRAY[CP_INFO].put*/
  638. /*No:FIXED_ARRAY[CP_INFO].upper*/
  639. void r515add_last(T515* C,T0* a1){
  640. int _new_capacity=0;
  641. /*IF*/if ((((((T515*)C))->_upper/*8*/)+(1))<=(((((T515*)C))->_capacity/*4*/)-(1))) {
  642. C->_upper=((((T515*)C))->_upper/*8*/)+(1);
  643. }
  644.  else if (((((T515*)C))->_capacity/*4*/)==(0)) {
  645. C->_storage=calloc(2,sizeof(T0*));
  646. C->_capacity=2;
  647. C->_upper=0;
  648. }
  649. else {
  650. _new_capacity=(2)*((((T515*)C))->_capacity/*4*/);
  651. C->_storage=r995realloc((((T515*)C))->_storage/*0*/,(((T515*)C))->_capacity/*4*/,_new_capacity);
  652. C->_capacity=_new_capacity;
  653. C->_upper=((((T515*)C))->_upper/*8*/)+(1);
  654. }
  655. /*FI*//*[IRF3.5put*/((((T515*)C))->_storage/*0*/)[(((T515*)C))->_upper/*8*/]=(a1);
  656. /*]*/
  657. }
  658.  
  659.